39.控制结构 ( if-else语句 、for循环 、while循环)

def calculate_tax(salary):
    """
    计算个人所得税(简化版)
    中国个人所得税采用7级超额累进税率
    """
    # 使用if-elif-else匹配累进税率表
    if salary <= 3000:
        rate, deduction = 0, 0
    elif salary <= 12000:
        rate, deduction = 0.03, 0
    elif salary <= 25000:
        rate, deduction = 0.10, 210
    elif salary <= 35000:
        rate, deduction = 0.20, 1410
    elif salary <= 55000:
        rate, deduction = 0.25, 2660
    elif salary <= 80000:
        rate, deduction = 0.30, 4410
    else:
        rate, deduction = 0.35, 7160

    # 应纳税所得额 = 税前工资 - 起征点(5000元)
    taxable_income = salary - 5000
    # 应纳税额 = 应纳税所得额 × 税率 - 速算扣除数
    tax = max(0, taxable_income * rate - deduction)
    after_tax = salary - tax
    return tax, after_tax

# 测试不同收入水平
salaries = [2500, 5000, 15000, 30000, 60000, 100000]
print('工资扣税计算:')
print('-' * 60)
for salary in salaries:
    tax, after_tax = calculate_tax(salary)
    tax_rate = tax / salary * 100 if salary > 0 else 0
    print(f'税前工资: {salary:8.2f}元 | 税额: {tax:7.2f}元 | 税率: {tax_rate:5.2f}% | 税后: {after_tax:8.2f}元')

def generate_signal(price, ma20, ma60, volume, avg_volume, rsi):
    """基于课堂数值字段的多条件嵌套判断"""
    signal = 'REVIEW'
    reason = []

    # 第一层：判断市场趋势（均线排列）
    if ma20 > ma60:
        reason.append('均线多头')
        # 第二层：价格是否突破均线
        if price > ma20:
            reason.append('突破20日均线')
            # 第三层：量价配合 + RSI确认
            if volume > avg_volume * 1.2 and rsi < 70:
                signal = 'RULE_A'
                reason.append('放量上涨')
    elif ma20 < ma60:
        reason.append('均线空头')
        if price < ma20:
            reason.append('跌破20日均线')
            if volume > avg_volume * 1.2 and rsi > 30:
                signal = 'RULE_B'
                reason.append('放量下跌')
    else:
        reason.append('均线接近,进入核对')

    return signal, '; '.join(reason)

# 测试不同市场情景
signals = [
    (18.5, 18.0, 17.5, 2500000, 2000000, 45),
    (18.5, 18.0, 17.5, 1500000, 2000000, 65),
    (18.5, 18.0, 17.5, 2500000, 2000000, 75),
    (16.5, 18.0, 17.5, 2500000, 2000000, 25),
]
print('课堂规则状态分析:')
print('-' * 80)
for price, ma20, ma60, volume, avg_vol, rsi in signals:
    signal, reason = generate_signal(price, ma20, ma60, volume, avg_vol, rsi)
    print(f'价格={price:.1f}, MA20={ma20:.1f}, MA60={ma60:.1f}, 状态={signal}, 原因=[{reason}]')

import numpy as np

# ===== 案例1：复利终值计算 =====
principal = 10000  # 本金
rate = 0.05        # 年利率5%
years = 10         # 投资10年

print('复利增长过程（打印第1年与偶数年以控制输出高度）:')  # 输出演示标题并说明抽样口径
print(f'{"年份":<6}{"利息":<12}{"年末余额":<12}')  # 输出表头，列宽用格式符对齐

amount = principal
# range(1, years+1) 生成 [1,2,...,10]，循环把每年利息计入余额
for year in range(1, years + 1):
    interest = amount * rate        # 当年利息
    amount += interest              # 累加到余额
    if year == 1 or year % 2 == 0:  # 仅输出首年与偶数年，保证结论行不被折叠隐藏
        print(f'{year:<6}{interest:<12.2f}{amount:<12.2f}')  # 输出当年利息与年末余额

# 复利 vs 单利对比
print(f'\n复利终值: {amount:.2f}元')
simple_interest = principal * (1 + rate * years)
print(f'单利对比: {simple_interest:.2f}元')
print(f'复利优势: {amount - simple_interest:.2f}元')

import numpy as np  # 导入数值运算工具以核对手算结果
daily_returns = [0.02, -0.01, 0.03, -0.02, 0.01, 0.04, -0.03, 0.02, -0.01, 0.01]  # 设置非市场观测的固定课堂演示序列
sample_size = len(daily_returns)  # 记录样本观测数以使用 n-1 分母
mean_daily_return = sum(daily_returns) / sample_size  # 计算日收益率样本均值
squared_deviation_sum = sum((daily_return - mean_daily_return) ** 2 for daily_return in daily_returns)  # 累计离差平方和
sample_variance = squared_deviation_sum / (sample_size - 1)  # 按 ddof=1 口径计算样本方差
annualization_factor = np.sqrt(252)  # 按252个交易日构造年化因子
manual_annualized_volatility = np.sqrt(sample_variance) * annualization_factor  # 将手算样本标准差年化
numpy_annualized_volatility = np.std(daily_returns, ddof=1) * annualization_factor  # 用相同样本口径调用 NumPy 核对
calculation_difference = abs(manual_annualized_volatility - numpy_annualized_volatility)  # 计算两种路径的绝对差异
print(f'样本口径: n={sample_size}, ddof=1, 年化因子=252')  # 显示可核对的统计口径
print(f'手算={manual_annualized_volatility:.2%} | NumPy={numpy_annualized_volatility:.2%} | 差异={calculation_difference:.2e}')  # 紧凑呈现一致的年化结果

import numpy as np

def sqrt_newton(x, tolerance=1e-6, max_iter=100):
    """
    牛顿迭代法计算√2
    迭代公式: x_{n+1} = 0.5 * (x_n + S/x_n)
    """
    S = 2.0
    x_old = x

    print(f'牛顿法求√{S}:')
    print(f'{"迭代":<6}{"近似值":<15}{"误差":<15}')
    print('-' * 40)

    for i in range(max_iter):
        x_new = 0.5 * (x_old + S / x_old)  # 牛顿迭代
        error = abs(x_new - x_old)           # 绝对误差
        print(f'{i+1:<6}{x_new:<15.10f}{error:<15.10f}')

        if error < tolerance:                # 检查收敛
            print(f'\n收敛! 迭代{i+1}次后达到精度要求')
            break
        x_old = x_new
    else:
        print(f'\n警告: 未在{max_iter}次内收敛')

    return x_new

import numpy as np  # 提供 Black-Scholes 公式所需的对数和平方根运算
from scipy.optimize import brentq  # 调用保持在给定区间内的 Brent 有界求根器
from scipy.stats import norm  # 计算标准正态分布累积概率
def black_scholes_call_price(spot_price, strike_price, time_years, risk_free_rate, volatility):  # 计算不分红欧式看涨期权理论价格
    d1 = (np.log(spot_price / strike_price) + (risk_free_rate + 0.5 * volatility**2) * time_years) / (volatility * np.sqrt(time_years))  # 标准化到期价格阈值
    d2 = d1 - volatility * np.sqrt(time_years)  # 将 d1 调整为行权概率阈值
    return spot_price * norm.cdf(d1) - strike_price * np.exp(-risk_free_rate * time_years) * norm.cdf(d2)  # 返回 Black-Scholes 看涨期权价格
def solve_implied_volatility(option_price, spot_price=100, strike_price=105, time_years=1, risk_free_rate=0.05, lower_bound=0.0001, upper_bound=3):  # 在给定波动率边界内反解隐含波动率
    lower_error = black_scholes_call_price(spot_price, strike_price, time_years, risk_free_rate, lower_bound) - option_price  # 计算下界价格误差
    upper_error = black_scholes_call_price(spot_price, strike_price, time_years, risk_free_rate, upper_bound) - option_price  # 计算上界价格误差
    if lower_error * upper_error > 0:  # 检查两端误差是否异号以确认区间内存在根
        return None, '失败：期权价格超出求解边界'  # 明确返回失败状态而不产生无效波动率
    pricing_error = lambda volatility: black_scholes_call_price(spot_price, strike_price, time_years, risk_free_rate, volatility) - option_price  # 定义理论价与输入价的差额函数
    bounded_volatility = brentq(pricing_error, lower_bound, upper_bound, xtol=1e-8)  # 在有效区间内定位价格误差的根
    return bounded_volatility, '求解成功'  # 返回有界解与明确状态
teaching_option_price = 8.02  # 设置非市场观测的确定性课堂价格输入
estimated_volatility, solver_status = solve_implied_volatility(teaching_option_price)  # 调用有界求根器并接收状态
print('课堂输入（非市场观测）: S=100, K=105, T=1, r=5%, 价格=8.02')  # 披露参数性质与完整输入
if estimated_volatility is None:  # 根据边界检查结果分流成功与失败状态
    print(solver_status)  # 在无根时显示明确失败原因
else:  # 在找到区间根时执行价格核对
    reconstructed_price = black_scholes_call_price(100, 105, 1, 0.05, estimated_volatility)  # 用反解波动率重新计算理论价
    print(f'{solver_status}: IV={estimated_volatility:.2%} | 核对价={reconstructed_price:.4f} | 残差={abs(reconstructed_price - teaching_option_price):.2e}')  # 紧凑呈现解、核对价与定价残差

# ===== break演示 =====
print('break演示(找到第一个正收益):')
returns = [-0.02, 0.03, -0.01, 0.04, 0.01, -0.03, 0.02]

for i, ret in enumerate(returns):
    if ret > 0:
        print(f'  第{i+1}天: {ret:.2%}')
        break  # 找到后立即退出

# ===== continue演示 =====
print('\ncontinue演示(跳过负收益):')
positive_count = 0
for ret in returns:
    if ret < 0:
        continue  # 负收益直接跳过
    positive_count += 1
    print(f'  正收益: {ret:.2%}')
print(f'\n正收益天数: {positive_count}天')

print('嵌套循环演示（2×2矩阵）:')  # 打印演示标题并控制输出高度
for i in range(2):  # 外层循环遍历行号
    for j in range(2):  # 内层循环遍历列号
        if i == j:  # 行列相等即为对角线元素
            print(f'  ({i}, {j}): 对角线元素')  # 输出对角线位置标识
        else:
            continue  # 非对角线跳过，保持循环继续
    # for-else：循环正常结束（未被break中断）时执行
    else:
        print(f'第{i}行完成')

def PV(R, *NCF, verbose=False):
    """
    计算各期现金流现值合计
    PV = Σ(CF_t / (1+r)^t)，t 自 1 起
    *NCF 接收任意数量的现金流
    """
    pv = 0
    n = 1
    for cf in NCF:
        discount_factor = 1 / (1 + R) ** n  # 第n期折现因子
        discounted_cf = cf * discount_factor  # 该期现金流现值
        pv += discounted_cf  # 逐期累加
        if verbose:
            print(f'  第{n}期: 现金流={cf:8.2f}, 折现因子={discount_factor:.6f}, 现值={discounted_cf:8.2f}')
        n += 1
    if verbose:
        print(f'现值总和: {pv:.2f}元')  # 输出折现合计供课堂核对
    return pv

# 案例1：简单投资项目（区分两种口径）
pv1 = PV(0.05, -10000, 8000, 12000)  # 期初流出也被当作第1期现金流折现
npv_t0 = -10000 + 8000 / 1.05 + 12000 / 1.05 ** 2  # 标准口径：期初流出在t=0不折现、流入自t=1起
print(f'案例1: 全部自第1期折现的合计 {pv1:.2f}元；期初流出口径NPV {npv_t0:.2f}元\n')  # 两种口径并列展示

# 案例2：多期项目（verbose展示逐期折现过程）
project_flows = [-50000, 15000, 20000, 25000]  # 四期课堂示例现金流
pv2 = PV(0.08, *project_flows, verbose=True)

# 案例3：债券定价（仅输出合计）
bond_flows = [50] * 9 + [1050]  # 10年期，票面5%，面值1000
pv_bond = PV(0.06, *bond_flows)
print(f'\n案例3: 债券现值 {pv_bond:.2f}元')  # 输出债券定价结果

import numpy as np

# ===== 阶乘 =====
def factorial(n):
    """n! = n × (n-1)!，基准: 0!=1, 1!=1"""
    if n <= 1:
        return 1
    return n * factorial(n - 1)

print('阶乘计算:')
for n in [1, 5, 10, 20]:
    print(f'{n}! = {factorial(n)}')

# ===== 斐波那契 =====
def fibonacci(n):
    """F(0)=0, F(1)=1, F(n)=F(n-1)+F(n-2)"""
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(f'\n斐波那契数列前10项:')
print([fibonacci(i) for i in range(10)])

import numpy as np

def binomial_tree(S, K, T, r, sigma, n, call=True):
    """
    Cox-Ross-Rubinstein二叉树模型
    u = e^(σ√dt), d = 1/u, p = (e^(r·dt) - d) / (u - d)
    """
    dt = T / n
    u = np.exp(sigma * np.sqrt(dt))   # 上涨因子
    d = 1 / u                          # 下跌因子
    p = (np.exp(r * dt) - d) / (u - d) # 风险中性概率

    # 终端节点期权价值
    option_values = np.zeros(n + 1)
    for j in range(n + 1):
        S_T = S * (u ** j) * (d ** (n - j))
        if call:
            option_values[j] = max(S_T - K, 0)
        else:
            option_values[j] = max(K - S_T, 0)

    # 从终端向根回推
    for i in range(n - 1, -1, -1):
        for j in range(i + 1):
            option_values[j] = np.exp(-r * dt) * (
                p * option_values[j + 1] + (1 - p) * option_values[j]
            )
    return option_values[0]

# 注：生产环境中可使用n=100或更高步数以提升精度
option_price = binomial_tree(S=100, K=105, T=1, r=0.05, sigma=0.2, n=20)
print(f'二叉树模型期权价格: {option_price:.2f}元')

x = 10  # 全局变量
y = 20

def func_local():
    """局部变量遮蔽全局变量"""
    x = 5  # 局部变量，不影响全局x
    print(f'函数内x: {x} (局部)')

def func_global():
    """使用global修改全局变量"""
    global y
    y = 50
    print(f'函数内y: {y} (修改后的全局)')

def func_enclosing():
    """闭包：内层函数访问外层变量"""
    z = 100
    def inner():
        return x + z  # x来自Global, z来自Enclosing
    return inner()

# 错误示例：忘记global
def modify_global_wrong():
    y = 30  # 创建局部变量，不影响全局y

print(f'\n错误示例测试:')
print(f'修改前全局y: {y}')
modify_global_wrong()
print(f'modify_global_wrong()后, 全局y: {y} (未修改,因为没有global)')

# 基本lambda函数
square = lambda x: x**2
cube = lambda x: x**3
print('lambda函数演示:')
print(f'平方: {square(5)} = {square(5)}')
print(f'立方: {cube(5)} = {cube(5)}')

# 金融收益率计算
simple_return = lambda initial, final: (final - initial) / initial
compound_return = lambda initial, rate, periods: initial * (1 + rate) ** periods - initial

print(f'\n简单收益率: {simple_return(100, 110):.2%}')
print(f'复利收益: {compound_return(10000, 0.05, 10):.2f}')

# 投资组合净值
net_value = lambda prices, shares: sum(p * s for p, s in zip(prices, shares))
prices = [10.5, 22.3, 15.8]
shares = [100, 200, 150]
print(f'\n投资组合净值: {net_value(prices, shares):.2f}元')

stocks = ['贵州茅台', '五粮液', '招商银行']
prices = [1850, 220, 45]

# map：对每个元素应用函数
formatted = list(map(lambda x: f'{x}元', prices))
print(f'格式化价格: {formatted}')

# filter：过滤符合条件的元素
expensive = list(filter(lambda p: p[1] > 200, zip(stocks, prices)))
print(f'高价股票: {[s + "=" + str(p) + "元" for s, p in expensive]}')

# sorted：自定义排序
portfolio = [
    {'name': '贵州茅台', 'return': 0.15},
    {'name': '五粮液', 'return': 0.08},
    {'name': '招商银行', 'return': 0.12}
]
sorted_portfolio = sorted(portfolio, key=lambda x: x['return'], reverse=True)
print(f'\n按收益率排序:')
for stock in sorted_portfolio:
    print(f"  {stock['name']}: {stock['return']:.2%}")